import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

/**
 * 泛型
 *      泛型的上界
 *      泛型方法
 * ArrayList->MyArrayList进行方法实现Test进行测试
 *
 */
class MyArray<T> {
    private Object[] array = new Object[10];
    public void setArray(int pos,T val) {
        this.array[pos] = val;
    }
    public T get(int pos) {
        return (T)this.array[pos];
    }
}

class Alg<T extends Comparable<T>> {
    public T findMax(T[] array) {
        T max = array[0];
        for(int i = 1;i < array.length;i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}
class Alg2 {
    public <T extends Comparable<T>> T findMax(T[] array) {
        T max = array[0];
        for(int i = 1;i < array.length;i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}
class Alg3 {
    public static <T extends Comparable<T>>  T findMax(T[] array) {
        T max = array[0];
        for(int i = 1;i < array.length;i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}
public class Test {
    /**
     * 遍历放入顺序表
     * @param str1
     * @param str2
     * @return
     */
    public static ArrayList<Character> func(String str1,String str2) {
        ArrayList<Character> ret = new ArrayList<>();
        for(int i = 0;i < str1.length();i++) {
            char ch = str1.charAt(i);
            //1.
//            int j = 0;
//            for(;j < str2.length();j++) {
//                if(ch == str2.charAt(j)) {
//                    break;
//                }
//
//            }
//            if(j >= str2.length()) {
//                ret.add(ch);
//            }
            //2.
            if(!str2.contains(ch+"")) {
                ret.add(ch);
            }
        }
        return ret;
    }
    public static void main(String[] args) {
        System.out.println(func("welcome to cvte","come"));
    }
    /**
     * ArrayList->顺序表
     * @param args
     *      常见操作
     *      ArrayList的遍历
     *      ArrayList的扩容机制
     */
    public static void main8(String[] args) {
        /**
         * ArrayList的扩容机制->看源码实现
         * 总结
         *      1.检测是否需要扩容,如果是调用grow则是需要扩容
         *      2.预估需要扩容的大小
         *              1.初步按照1.5x进行扩容
         *              2.如果用户需求超过1.5,则按用户需求扩容
         *              3.真正扩容之前,先检查是否扩容成功,防止太大导致扩容失败
         *      3.使用copeOf()进行扩容
         */
    }
    /**
     * ArrayList的遍历
     * @param args
     *      1.直接打印
     *      2.for循环
     *      3.for-each循环
     *      4.Iteron迭代器
     *      5.
     *      6.从后往前打印
     */
    public static void main7(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        //1.直接打印
        System.out.println(arrayList);
        //2.for循环
        for(int i = 0;i < arrayList.size();i++) {
            System.out.print(arrayList.get(i) + " ");
        }
        System.out.println();
        //3.for-each循环
        for(Integer i:arrayList) {
            System.out.print(i + " ");
        }
        System.out.println();
        //4.Iterator迭代器
        Iterator<Integer> it1 = arrayList.iterator();
        while(it1.hasNext()) {
            System.out.print(it1.next() + " ");
        }
        System.out.println();
        //5.ListIterator子类迭代器
        ListIterator<Integer> it2 = arrayList.listIterator();
        while(it2.hasNext()) {
            System.out.print(it2.next() + " ");
        }
        System.out.println();
        //6.从后向前打印
        ListIterator<Integer> it3 = arrayList.listIterator(arrayList.size());
        while(it3.hasPrevious()) {
            System.out.print(it3.previous() + " ");
        }
        System.out.println();
    }
    public static void main6(String[] args) {
        /**
         * subList方法
         *      截取方法->在原本引用对象的基础上进行截取,如果进行改变,则原对象也会发生改变.
         */
    }
    public static void main5(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(3);
        myArrayList.add(4);
        myArrayList.add(5);
        myArrayList.display();

        myArrayList.add(1,9);
        myArrayList.display();

        System.out.println(myArrayList.contains(9));

        System.out.println(myArrayList.indexOf(11));

        myArrayList.remove(5);
        myArrayList.display();
    }
    /**
     *泛型方法
     * @param args
     *      泛型语法格式:修饰符 (static,根据需求添加) <类型形参> 返回类型 方法名(类型形参,形参...)
     *      调用方法时的两种方式:
     *      1.使用类型推导
     *      2.不使用类型推导
     */
    //静态方法,不需要实例化对象
    public static void main4(String[] args) {
        Integer[] integer = {10,3,5,11,4};

        System.out.println(Alg3.findMax(integer));
        System.out.println(Alg3.<Integer>findMax(integer));
    }
    //不使用类型推导
    public static void main3(String[] args) {
        Integer[] integer = {10,3,5,11,4};
        Alg2 alg2 = new Alg2();

        System.out.println(alg2.<Integer>findMax(integer));
    }
    //使用类型推导
    public static void main2(String[] args) {
        Integer[] integer = {10,3,5,11,4};
        Alg2 alg2 = new Alg2();

        System.out.println(alg2.findMax(integer));
    }
    /**
     * 泛型的上界
     * @param args
     *      语法格式:class 泛型类<类型实参 extends 类型边界>
     *            类型实参必须是类型边界/类型边界的子类
     */

    public static void main1(String[] args) {
        Integer[] integer = {10,3,5,11,4};
        Alg alg = new Alg();
        System.out.println(alg.findMax(integer));
    }
}
